package com.ruoyi.system.service.impl;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.common.constant.Constants;
import com.ruoyi.common.constant.PublishConstants;
import com.ruoyi.common.constant.SysConfigConstants;
import com.ruoyi.common.constant.UserConstants;
import com.ruoyi.common.core.domain.PageQuery;
import com.ruoyi.common.core.domain.entity.SysDept;
import com.ruoyi.common.core.domain.entity.SysDictData;
import com.ruoyi.common.core.domain.entity.SysRole;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.helper.DataBaseHelper;
import com.ruoyi.common.helper.LoginHelper;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.redis.RedisUtils;
import com.ruoyi.system.domain.*;
import com.ruoyi.system.mapper.*;
import com.ruoyi.system.service.ISysUserService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.ObjectUtils;

import java.math.BigDecimal;
import java.time.Duration;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 用户 业务层处理
 *
 * @author Lion Li
 */
@Slf4j
@RequiredArgsConstructor
@Service
public class SysUserServiceImpl implements ISysUserService {

    private final SysUserMapper baseMapper;
    private final SysDeptMapper deptMapper;
    private final SysRoleMapper roleMapper;
    private final SysPostMapper postMapper;
    private final SysUserRoleMapper userRoleMapper;
    private final SysUserPostMapper userPostMapper;
    private final PCommonGoodMapper commonGoodMapper;
    private final PResumeMapper resumeMapper;
    private final PUserBillMapper pUserBillMapper;
    private final SysDictDataMapper sysDictDataMapper;
    private final PUserSignMapper pUserSignMapper;

    @Override
    public TableDataInfo<SysUser> selectPageUserList(SysUser user, PageQuery pageQuery) {
        Page<SysUser> page = baseMapper.selectPageUserList(pageQuery.build(), this.buildQueryWrapper(user));
        return TableDataInfo.build(page);
    }

    /**
     * 根据条件分页查询用户列表
     *
     * @param user 用户信息
     * @return 用户信息集合信息
     */
    @Override
    public List<SysUser> selectUserList(SysUser user) {
        return baseMapper.selectUserList(this.buildQueryWrapper(user));
    }

    private Wrapper<SysUser> buildQueryWrapper(SysUser user) {
        Map<String, Object> params = user.getParams();
        QueryWrapper<SysUser> wrapper = Wrappers.query();
        wrapper.eq("u.del_flag", UserConstants.USER_NORMAL)
            .eq(ObjectUtil.isNotNull(user.getUserId()), "u.user_id", user.getUserId())
            .like(StringUtils.isNotBlank(user.getUserName()), "u.user_name", user.getUserName())
            .eq(StringUtils.isNotBlank(user.getStatus()), "u.status", user.getStatus())
            .like(StringUtils.isNotBlank(user.getPhonenumber()), "u.phonenumber", user.getPhonenumber())
            .between(params.get("beginTime") != null && params.get("endTime") != null,
                "u.create_time", params.get("beginTime"), params.get("endTime"))
            .and(ObjectUtil.isNotNull(user.getDeptId()), w -> {
                List<SysDept> deptList = deptMapper.selectList(new LambdaQueryWrapper<SysDept>()
                    .select(SysDept::getDeptId)
                    .apply(DataBaseHelper.findInSet(user.getDeptId(), "ancestors")));
                List<Long> ids = deptList.stream().map(SysDept::getDeptId).collect(Collectors.toList());
                ids.add(user.getDeptId());
                w.in("u.dept_id", ids);
            });
        return wrapper;
    }

    /**
     * 根据条件分页查询已分配用户角色列表
     *
     * @param user 用户信息
     * @return 用户信息集合信息
     */
    @Override
    public TableDataInfo<SysUser> selectAllocatedList(SysUser user, PageQuery pageQuery) {
        QueryWrapper<SysUser> wrapper = Wrappers.query();
        wrapper.eq("u.del_flag", UserConstants.USER_NORMAL)
            .eq(ObjectUtil.isNotNull(user.getRoleId()), "r.role_id", user.getRoleId())
            .like(StringUtils.isNotBlank(user.getUserName()), "u.user_name", user.getUserName())
            .eq(StringUtils.isNotBlank(user.getStatus()), "u.status", user.getStatus())
            .like(StringUtils.isNotBlank(user.getPhonenumber()), "u.phonenumber", user.getPhonenumber());
        Page<SysUser> page = baseMapper.selectAllocatedList(pageQuery.build(), wrapper);
        return TableDataInfo.build(page);
    }

    /**
     * 根据条件分页查询未分配用户角色列表
     *
     * @param user 用户信息
     * @return 用户信息集合信息
     */
    @Override
    public TableDataInfo<SysUser> selectUnallocatedList(SysUser user, PageQuery pageQuery) {
        List<Long> userIds = userRoleMapper.selectUserIdsByRoleId(user.getRoleId());
        QueryWrapper<SysUser> wrapper = Wrappers.query();
        wrapper.eq("u.del_flag", UserConstants.USER_NORMAL)
            .and(w -> w.ne("r.role_id", user.getRoleId()).or().isNull("r.role_id"))
            .notIn(CollUtil.isNotEmpty(userIds), "u.user_id", userIds)
            .like(StringUtils.isNotBlank(user.getUserName()), "u.user_name", user.getUserName())
            .like(StringUtils.isNotBlank(user.getPhonenumber()), "u.phonenumber", user.getPhonenumber());
        Page<SysUser> page = baseMapper.selectUnallocatedList(pageQuery.build(), wrapper);
        return TableDataInfo.build(page);
    }

    /**
     * 通过用户名查询用户
     *
     * @param userName 用户名
     * @return 用户对象信息
     */
    @Override
    public SysUser selectUserByUserName(String userName) {
        return baseMapper.selectUserByUserName(userName);
    }

    /**
     * 通过手机号查询用户
     *
     * @param phonenumber 手机号
     * @return 用户对象信息
     */
    @Override
    public SysUser selectUserByPhonenumber(String phonenumber) {
        return baseMapper.selectUserByPhonenumber(phonenumber);
    }

    /**
     * 通过用户ID查询用户
     *
     * @param userId 用户ID
     * @return 用户对象信息
     */
    @Override
    public SysUser selectUserById(Long userId) {
        return baseMapper.selectUserById(userId);
    }

    /**
     * 查询用户所属角色组
     *
     * @param userName 用户名
     * @return 结果
     */
    @Override
    public String selectUserRoleGroup(String userName) {
        List<SysRole> list = roleMapper.selectRolesByUserName(userName);
        if (CollUtil.isEmpty(list)) {
            return StringUtils.EMPTY;
        }
        return list.stream().map(SysRole::getRoleName).collect(Collectors.joining(","));
    }

    /**
     * 查询用户所属岗位组
     *
     * @param userName 用户名
     * @return 结果
     */
    @Override
    public String selectUserPostGroup(String userName) {
        List<SysPost> list = postMapper.selectPostsByUserName(userName);
        if (CollUtil.isEmpty(list)) {
            return StringUtils.EMPTY;
        }
        return list.stream().map(SysPost::getPostName).collect(Collectors.joining(","));
    }

    /**
     * 校验用户名称是否唯一
     *
     * @param userName 用户名称
     * @return 结果
     */
    @Override
    public String checkUserNameUnique(String userName) {
        boolean exist = baseMapper.exists(new LambdaQueryWrapper<SysUser>().eq(SysUser::getUserName, userName));
        if (exist) {
            return UserConstants.NOT_UNIQUE;
        }
        return UserConstants.UNIQUE;
    }

    /**
     * 校验手机号码是否唯一
     *
     * @param user 用户信息
     * @return
     */
    @Override
    public String checkPhoneUnique(SysUser user) {
        boolean exist = baseMapper.exists(new LambdaQueryWrapper<SysUser>()
            .eq(SysUser::getPhonenumber, user.getPhonenumber())
            .ne(ObjectUtil.isNotNull(user.getUserId()), SysUser::getUserId, user.getUserId()));
        if (exist) {
            return UserConstants.NOT_UNIQUE;
        }
        return UserConstants.UNIQUE;
    }

    /**
     * 校验email是否唯一
     *
     * @param user 用户信息
     * @return
     */
    @Override
    public String checkEmailUnique(SysUser user) {
        boolean exist = baseMapper.exists(new LambdaQueryWrapper<SysUser>()
            .eq(SysUser::getEmail, user.getEmail())
            .ne(ObjectUtil.isNotNull(user.getUserId()), SysUser::getUserId, user.getUserId()));
        if (exist) {
            return UserConstants.NOT_UNIQUE;
        }
        return UserConstants.UNIQUE;
    }

    /**
     * 校验用户是否允许操作
     *
     * @param user 用户信息
     */
    @Override
    public void checkUserAllowed(SysUser user) {
        if (ObjectUtil.isNotNull(user.getUserId()) && user.isAdmin()) {
            throw new ServiceException("不允许操作超级管理员用户");
        }
    }

    /**
     * 校验用户是否有数据权限
     *
     * @param userId 用户id
     */
    @Override
    public void checkUserDataScope(Long userId) {
        if (!LoginHelper.isAdmin()) {
            SysUser user = new SysUser();
            user.setUserId(userId);
            List<SysUser> users = this.selectUserList(user);
            if (CollUtil.isEmpty(users)) {
                throw new ServiceException("没有权限访问用户数据！");
            }
        }
    }

    /**
     * 新增保存用户信息
     *
     * @param user 用户信息
     * @return 结果
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public int insertUser(SysUser user) {
        // 新增用户信息
        int rows = baseMapper.insert(user);
        // 新增用户岗位关联
        insertUserPost(user);
        // 新增用户与角色管理
        insertUserRole(user);
        return rows;
    }

    /**
     * 注册用户信息
     *
     * @param user 用户信息
     * @return 结果
     */
    @Override
    public boolean registerUser(SysUser user) {
        user.setCreateBy(user.getUserName());
        user.setUpdateBy(user.getUserName());
        return baseMapper.insert(user) > 0;
    }

    /**
     * 修改保存用户信息
     *
     * @param user 用户信息
     * @return 结果
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public int updateUser(SysUser user) {
        Long userId = user.getUserId();
        // 删除用户与角色关联
        userRoleMapper.delete(new LambdaQueryWrapper<SysUserRole>().eq(SysUserRole::getUserId, userId));
        // 新增用户与角色管理
        insertUserRole(user);
        // 删除用户与岗位关联
        userPostMapper.delete(new LambdaQueryWrapper<SysUserPost>().eq(SysUserPost::getUserId, userId));
        // 新增用户与岗位管理
        insertUserPost(user);
        return baseMapper.updateById(user);
    }

    /**
     * 用户授权角色
     *
     * @param userId  用户ID
     * @param roleIds 角色组
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void insertUserAuth(Long userId, Long[] roleIds) {
        userRoleMapper.delete(new LambdaQueryWrapper<SysUserRole>()
            .eq(SysUserRole::getUserId, userId));
        insertUserRole(userId, roleIds);
    }

    /**
     * 修改用户状态
     *
     * @param user 用户信息
     * @return 结果
     */
    @Override
    public int updateUserStatus(SysUser user) {
        return baseMapper.updateById(user);
    }

    /**
     * 修改用户基本信息
     *
     * @param user 用户信息
     * @return 结果
     */
    @Override
    public int updateUserProfile(SysUser user) {
        return baseMapper.updateById(user);
    }

    /**
     * 修改用户头像
     *
     * @param userName 用户名
     * @param avatar   头像地址
     * @return 结果
     */
    @Override
    public boolean updateUserAvatar(String userName, String avatar) {
        return baseMapper.update(null,
            new LambdaUpdateWrapper<SysUser>()
                .set(SysUser::getAvatar, avatar)
                .eq(SysUser::getUserName, userName)) > 0;
    }

    /**
     * 重置用户密码
     *
     * @param user 用户信息
     * @return 结果
     */
    @Override
    public int resetPwd(SysUser user) {
        return baseMapper.updateById(user);
    }

    /**
     * 重置用户密码
     *
     * @param userName 用户名
     * @param password 密码
     * @return 结果
     */
    @Override
    public int resetUserPwd(String userName, String password) {
        return baseMapper.update(null,
            new LambdaUpdateWrapper<SysUser>()
                .set(SysUser::getPassword, password)
                .eq(SysUser::getUserName, userName));
    }

    /**
     * 新增用户角色信息
     *
     * @param user 用户对象
     */
    public void insertUserRole(SysUser user) {
        this.insertUserRole(user.getUserId(), user.getRoleIds());
    }

    /**
     * 新增用户岗位信息
     *
     * @param user 用户对象
     */
    public void insertUserPost(SysUser user) {
        Long[] posts = user.getPostIds();
        if (ArrayUtil.isNotEmpty(posts)) {
            // 新增用户与岗位管理
            List<SysUserPost> list = new ArrayList<>(posts.length);
            for (Long postId : posts) {
                SysUserPost up = new SysUserPost();
                up.setUserId(user.getUserId());
                up.setPostId(postId);
                list.add(up);
            }
            userPostMapper.insertBatch(list);
        }
    }

    /**
     * 新增用户角色信息
     *
     * @param userId  用户ID
     * @param roleIds 角色组
     */
    public void insertUserRole(Long userId, Long[] roleIds) {
        if (ArrayUtil.isNotEmpty(roleIds)) {
            // 新增用户与角色管理
            List<SysUserRole> list = new ArrayList<>(roleIds.length);
            for (Long roleId : roleIds) {
                SysUserRole ur = new SysUserRole();
                ur.setUserId(userId);
                ur.setRoleId(roleId);
                list.add(ur);
            }
            userRoleMapper.insertBatch(list);
        }
    }

    /**
     * 通过用户ID删除用户
     *
     * @param userId 用户ID
     * @return 结果
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public int deleteUserById(Long userId) {
        // 删除用户与角色关联
        userRoleMapper.delete(new LambdaQueryWrapper<SysUserRole>().eq(SysUserRole::getUserId, userId));
        // 删除用户与岗位表
        userPostMapper.delete(new LambdaQueryWrapper<SysUserPost>().eq(SysUserPost::getUserId, userId));
        return baseMapper.deleteById(userId);
    }

    /**
     * 批量删除用户信息
     *
     * @param userIds 需要删除的用户ID
     * @return 结果
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public int deleteUserByIds(Long[] userIds) {
        for (Long userId : userIds) {
            checkUserAllowed(new SysUser(userId));
            checkUserDataScope(userId);
        }
        List<Long> ids = Arrays.asList(userIds);
        // 删除用户与角色关联
        userRoleMapper.delete(new LambdaQueryWrapper<SysUserRole>().in(SysUserRole::getUserId, ids));
        // 删除用户与岗位表
        userPostMapper.delete(new LambdaQueryWrapper<SysUserPost>().in(SysUserPost::getUserId, ids));
        return baseMapper.deleteBatchIds(ids);
    }

    @Override
    public TableDataInfo<SysUser> selectPublicList(SysUser user, PageQuery pageQuery) {
        QueryWrapper<SysUser> wrapper = Wrappers.query();
        wrapper.eq("u.del_flag", UserConstants.USER_NORMAL)
            .eq(StringUtils.isNotBlank(user.getUserType()), "u.user_type", user.getUserType())
            .eq(ObjectUtil.isNotEmpty(user.getSpreadId()), "u.spread_id", user.getSpreadId())
            .eq(ObjectUtil.isNotEmpty(user.getWelfareSwitch()), "u.welfare_switch", user.getWelfareSwitch());
        Page<SysUser> page = baseMapper.selectPublicList(pageQuery.build(), wrapper, PublishConstants.ADVISER_TYPE);
        return TableDataInfo.build(page);
    }

    @Override
    public List<SysUser> selectHelpPublicList() {
        return baseMapper.selectkanbanList();
    }

    @Override
    public TableDataInfo<SysUser> selectIndexUser(SysUser user, PageQuery pageQuery) {
        QueryWrapper<SysUser> wrapper = Wrappers.query();
        wrapper.eq("u.del_flag", UserConstants.USER_NORMAL)
            .eq("u.user_type", PublishConstants.ADVERSE_TYPE)
            .eq(ObjectUtil.isNotNull(user.getAskId()), "t.ask_id", user.getAskId())
            .eq(StringUtils.isNotBlank(user.getSex()), "u.sex", user.getSex());

        Page<SysUser> page = baseMapper.selectIndexUser(pageQuery.build(), wrapper);

        return TableDataInfo.build(page);
    }

    @Override
    public SysUser queryUserInfo(Long id) {
        return baseMapper.selectUserInfoById(id);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void insertFont(SysUser user) {
        if (ObjectUtil.isEmpty(user)) {
            throw new ServiceException("必要参数不能为空!");
        }

        Long userId = user.getUserId();
        if (ObjectUtil.isEmpty(userId)) {
            user.setUserId(LoginHelper.getUserId());
        }

        SysUser sysUser = baseMapper.selectById(user.getUserId());
        String isFlag = sysUser.getIsFlag();
        if (StringUtils.isNotBlank(isFlag) && isFlag.equals("0")) {
            throw new ServiceException("审批中，请勿重复入驻！");
        }

        if ("1".equals(isFlag)) {
            throw new ServiceException("已是咨询师！");
        }
        // 等待管理员审批
        user.setIsFlag("0");
        baseMapper.updateById(user);
        // 插入擅长领域中间表
        String common = user.getCommon();
        if (StringUtils.isNotBlank(common)) {
            String[] str = common.split(",");
            if (str.length > 0) {
                // 定义缓存集合
                List<PCommonGood> list = new ArrayList<>();
                for (int i = 0; i < str.length; i++) {
                    PCommonGood commonGood = new PCommonGood();
                    commonGood.setUserId(user.getUserId());
                    commonGood.setAskId(Long.parseLong(str[i]));
                    list.add(commonGood);
                }
                // 批量导入
                commonGoodMapper.insertBatch(list);
            }
        }

        // 插入咨询师简历
        PResume resume = new PResume();
        resume.setUserId(user.getUserId());
        resume.setStartWorkTime(user.getStartWorkTime());
        resume.setDescInfo(user.getDescInfo());
        resumeMapper.insert(resume);
    }

    @Override
    public SysUser selectUserFontById(Long userId) {
        return baseMapper.selectUserFontById(userId);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void bindingPromoter(Long spreadId) {
        SysUser hasUser = baseMapper.selectUserById(spreadId);
        if (ObjectUtil.isNull(hasUser)) {
            throw new ServiceException("非法推广人！");
        }

        Long userId = LoginHelper.getUserId();
        SysUser sysUser = new SysUser();
        sysUser.setUserId(userId);
        sysUser.setSpreadId(spreadId);

        baseMapper.updateById(sysUser);
    }

    @Override
    public SysUser selectUserByWxOpenId(String openid) {
        return baseMapper.selectOne(new LambdaQueryWrapper<SysUser>()
            .eq(SysUser::getWeixinOpenid, openid));
    }

    @Override
    public TableDataInfo<SysUser> selectPageMyUserList(SysUser user, PageQuery pageQuery) {
        Map<String, Object> params = user.getParams();
        QueryWrapper<SysUser> wrapper = Wrappers.query();
        wrapper.eq("u.del_flag", UserConstants.USER_NORMAL)
            .eq(StringUtils.isNotBlank(user.getUserType()), "u.user_type", user.getUserType())
            .eq(ObjectUtil.isNotNull(user.getUserId()), "u.user_id", user.getUserId())
            .eq(StringUtils.isNotBlank(user.getIsRecommend()), "u.is_recommend", user.getIsRecommend())
            .like(StringUtils.isNotBlank(user.getUserName()), "u.user_name", user.getUserName())
            .eq(StringUtils.isNotBlank(user.getStatus()), "u.status", user.getStatus())
            .between(params.get("beginTime") != null && params.get("endTime") != null,
                "u.create_time", params.get("beginTime"), params.get("endTime"));

        Page<SysUser> page = baseMapper.selectPageMyUserList(pageQuery.build(), wrapper);

        return TableDataInfo.build(page);
    }

    @Override
    public void insertRegister(SysUser registerUser) {
        baseMapper.insert(registerUser);
    }

    @Override
    public void updateFontUser(SysUser user) {
        if (ObjectUtil.isEmpty(user)) {
            throw new ServiceException("非法参数！");
        }

        if (ObjectUtil.isEmpty(user.getUserId())) {
            throw new ServiceException("必要参数不能为空！");
        }

        baseMapper.updateById(user);
    }

    @Override
    public TableDataInfo<SysUser> selectPageRecommendUserList(SysUser user, PageQuery pageQuery) {
        Map<String, Object> params = user.getParams();
        QueryWrapper<SysUser> wrapper = Wrappers.query();
        wrapper.eq("u.del_flag", UserConstants.USER_NORMAL)
            .eq(StringUtils.isNotBlank(user.getUserType()), "u.user_type", user.getUserType())
            .eq(ObjectUtil.isNotNull(user.getUserId()), "u.user_id", user.getUserId())
            .eq(StringUtils.isNotBlank(user.getIsRecommend()), "u.is_recommend", user.getIsRecommend())
            .like(StringUtils.isNotBlank(user.getUserName()), "u.user_name", user.getUserName())
            .like(StringUtils.isNotBlank(user.getRealName()), "u.real_name", user.getRealName())
            .like(StringUtils.isNotBlank(user.getNickName()), "u.nick_name", user.getNickName())
            .eq(StringUtils.isNotBlank(user.getStatus()), "u.status", user.getStatus())
            .eq(ObjectUtil.isNotEmpty(user.getAskId()), "c.ask_id", user.getAskId())
            .eq(StringUtils.isNotBlank(user.getLevelInfo()), "r.level_info", user.getLevelInfo())
            .between(params.get("beginTime") != null && params.get("endTime") != null,
                "u.create_time", params.get("beginTime"), params.get("endTime"));

        String selectType = user.getSelectType();
        if (StringUtils.isNotBlank(selectType)) {
            if (PublishConstants.PERSON_MAX.equals(selectType)) {
                wrapper.orderByDesc("score");
            }

            if (PublishConstants.PRICE_MIN.equals(selectType)) {
                wrapper.orderByAsc("r.price");
            }

            if (PublishConstants.PRICE_MAX.equals(selectType)) {
                wrapper.orderByDesc("r.price");
            }

            if (PublishConstants.NEW_ADD.equals(selectType)) {
                wrapper.orderByDesc("u.create_time");
            }

        }

        Page<SysUser> page = baseMapper.selectPageRecommendUserList(pageQuery.build(), wrapper);

        return TableDataInfo.build(page);
    }

    @Override
    public List<SysUser> getMyTeam() {
        List<Long> ids = new ArrayList<>();
        ids.add(LoginHelper.getUserId());

        List<SysUser> list = this.baseMapper.selectListTeam(ids);
        if(list.size() == 0) {
            return new ArrayList<>();
        }

        for (int i = 0; i < SysConfigConstants.DISTRIBUTION_LEVEL; i++) {
            list.addAll(this.listLowerLevel(list));
        }
        return list;
    }

    private List<SysUser> listLowerLevel(List<SysUser> list) {
        List<Long> ids = list.stream().map(SysUser::getUserId).collect(Collectors.toList());
        List<SysUser> result = this.baseMapper.selectListTeam(ids);
        if (result.size() == 0) {
            return new ArrayList<>();
        }
        return result;
    }

    @Override
    public SysUser getDistributionCenter() {
        List<Long> ids = this.getMyTeam().stream().map(SysUser::getUserId).collect(Collectors.toList());
        return this.baseMapper.distributionCenter(ids, LoginHelper.getUserId()).setMyTeamCount(ids.size());
    }

    @Override
    public SysUser adviserInfo() {
        SysUser user = this.baseMapper.selectOne(new LambdaQueryWrapper<SysUser>().select(SysUser::getUserId, SysUser::getIsOnline, SysUser::getLoginTime, SysUser::getOnlineTime)
            .eq(SysUser::getUserId, LoginHelper.getUserId()));
        if (!ObjectUtils.isEmpty(user.getIsOnline()) && user.getIsOnline()) {
            Date now = new Date();
            long subTime = now.getTime() - user.getLoginTime().getTime();
            this.baseMapper.update(null, new LambdaUpdateWrapper<SysUser>()
                .set(SysUser::getLoginTime, now)
                .set(SysUser::getOnlineTime, user.getOnlineTime().add(new BigDecimal(subTime / 1000 / 60 /60)))
                .eq(SysUser::getUserId, LoginHelper.getUserId()));
        }
        return this.baseMapper.adviserInfo(LoginHelper.getUserId());
    }

    @Override
    public SysUser scheduleConfig() {
        return this.baseMapper.selectOne(new LambdaQueryWrapper<SysUser>()
            .select(SysUser::getIsHelp, SysUser::getWelfareSwitch, SysUser::getIsOnline)
            .eq(SysUser::getUserId, LoginHelper.getUserId()));
    }

    @Override
    public void onlineState(String welfareSwitch, Boolean isOnline) {
        SysUser user = this.baseMapper.selectOne(new LambdaQueryWrapper<SysUser>().select(SysUser::getUserId, SysUser::getLoginTime, SysUser::getOnlineTime).eq(SysUser::getUserId, LoginHelper.getUserId()));
        Date now = new Date();
        // 第一次登录咨询师端， 判断登录时间是否为空
        Date lastLogin = user.getLoginTime();
        if (ObjectUtils.isEmpty(lastLogin)) {
            lastLogin = new Date();
        }

        long subTime = now.getTime() - lastLogin.getTime();

        this.baseMapper.update(null, new LambdaUpdateWrapper<SysUser>()
            .set(SysUser::getWelfareSwitch, welfareSwitch)
            .set(SysUser::getIsOnline, isOnline)
            .set(isOnline, SysUser::getLoginTime, now)
            .set(!isOnline, SysUser::getUnloginTime, now)
            .set(!isOnline, SysUser::getOnlineTime, user.getOnlineTime().add(new BigDecimal(subTime / 1000 / 60 /60)))
            .eq(SysUser::getUserId, LoginHelper.getUserId()));
    }

    @Override
    public Map<String, Object> toDo() {
        SysUser user = this.baseMapper.selectToDo(LoginHelper.getUserId());
        Map<String, Object> map = new HashMap<>();
        map.put("toService", user.getToService());
        map.put("newMessage", user.getNewMessage());
        map.put("monthCustomer", user.getMonthCustomer());
        return map;
    }

    @Override
    public SysUser selectFrontById(Long userId) {
        return baseMapper.selectById(userId);
    }

    @Override
    public TableDataInfo<PUserBill> integralDetail(PageQuery pageQuery) {
        pageQuery.setPageNum((pageQuery.getPageNum() - 1) * pageQuery.getPageSize());
        return TableDataInfo.build(this.pUserBillMapper.integralDetail(LoginHelper.getUserId(), pageQuery));
    }

    @Override
    public void dailyCheck() {
        Calendar now = Calendar.getInstance();
        StringBuilder str = new StringBuilder();
        str.append(Constants.DAILY_CHECK)
            .append(":")
            .append(now.get(Calendar.MONTH) + 1)
            .append(":")
            .append(now.get(Calendar.DAY_OF_MONTH))
            .append(":")
            .append(LoginHelper.getUserId());
        if (RedisUtils.hasKey(str.toString())) {
            throw new ServiceException("今日已签到");
        }
        SysDictData data = this.sysDictDataMapper.selectOne(new LambdaQueryWrapper<SysDictData>().eq(SysDictData::getDictType, "sys_common_type").eq(SysDictData::getDictLabel, "daily_check"));
        Integer systemIntegral = new Integer(data.getDictValue());
        SysUser user = this.baseMapper.selectOne(new LambdaQueryWrapper<SysUser>().select(SysUser::getUserId, SysUser::getIntegral).eq(SysUser::getUserId, LoginHelper.getUserId()));
        if (this.baseMapper.update(null, new LambdaUpdateWrapper<SysUser>().set(SysUser::getIntegral, user.getIntegral() + systemIntegral).eq(SysUser::getUserId, LoginHelper.getUserId())) == 1) {
            RedisUtils.setCacheObject(str.toString(), "", Duration.ofDays(1));
            PUserSign sign = new PUserSign();
            sign.setUserId(LoginHelper.getUserId())
                .setSignScore(systemIntegral);
            this.pUserSignMapper.insert(sign);
        }
    }

    @Override
    public void recharge(String orderNo) {
        PUserBill bill = this.pUserBillMapper.selectOne(new LambdaQueryWrapper<PUserBill>().eq(PUserBill::getOrderNo, orderNo));
        SysUser user = this.baseMapper.selectOne(new LambdaQueryWrapper<SysUser>().eq(SysUser::getUserId, bill.getUserId()));
        this.baseMapper.update(null, new LambdaUpdateWrapper<SysUser>().set(SysUser::getBalance, user.getBalance().add(bill.getNumber())).eq(SysUser::getUserId, user.getUserId()));
    }

}
